import org.junit.jupiter.api.BeforeEach;
import java.util.ArrayList;
import java.util.Arrays;

import static org.junit.jupiter.api.Assertions.*;

class NGuessNumberTest {
    NGuessNumber ngn;
    boolean isLegalAnswers(ArrayList<Integer> answes){
        //检查是否有⼩于0⼤于9的数或者是否有重复的数字，如果有就返回false
        for(int i = 0; i < answes.size(); i++){
            if(answes.get(i) < 0 || answes.get(i) > 9){
                return false;
            }
            for (int j = i+1; j < answes.size(); j++) {
                if (answes.get(i) == answes.get(j)){
                    return false;
                }
            }
        }
        return true;

    }

    @org.junit.jupiter.api.BeforeEach
    void setUp() {
        ngn = new NGuessNumber();
    }

    @org.junit.jupiter.api.Test
    void generateAnswer() {
        ArrayList<Integer> answers = NGuessNumber.generateAnswer();
        //断言answers列表的长度是否和预期的4一样，一样则测试通过，否则测试未通过
        assertEquals(4, answers.size());
        //断言isLegalAnswers方法返回的是否为真，是则测试通过，否则测试未通过
        assertTrue(isLegalAnswers(answers));
    }

    @org.junit.jupiter.api.Test
    void getA() {
        //指定1、2、3、4为答案数字
        Integer [] answers = {1,2,3,4};
        ngn.answers = new ArrayList<Integer>(Arrays.asList(answers));

        //指定5、6、7、8为第⼀种情况下的猜测数字
        Integer [] guesses = {5,6,7,8};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses));

        //判断第⼀种情况下getA⽅法是否可以正常返回结果
        assertEquals(0, ngn.getA());

        //指定1、2、3、4为第⼆种情况下的猜测数字
        Integer [] guesses1 = {1,2,3,4};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses1));

        //判断第⼆种情况下getA⽅法是否可以正常返回结果
        assertEquals(4, ngn.getA());

        //指定0、2、5、6为第三种情况下的猜测数字
        Integer [] guesses2 = {0,2,5,6};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses2));

        //判断第三种情况下getA⽅法是否可以正常返回结果
        assertEquals(1, ngn.getA());

        //指定0、2、3、6为第四种情况下的猜测数字
        Integer [] guesses3 = {0,2,3,6};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses3));

        //判断第三种情况下getA⽅法是否可以正常返回结果
        assertEquals(2, ngn.getA());

        //指定0、2、3、4为第三种情况下的猜测数字
        Integer [] guesses4 = {0,2,3,4};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses4));
        //判断第三种情况下getA⽅法是否可以正常返回结果
        assertEquals(3, ngn.getA());
    }


    @org.junit.jupiter.api.Test
    void getB() {
        //指定1、2、3、4为答案数字
        Integer [] answers = {1,2,3,4};
        ngn.answers = new ArrayList<Integer>(Arrays.asList(answers));

        //指定5、6、7、8为第⼀种情况下的猜测数字
        Integer [] guesses = {5,6,7,8};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses));

        //判断第⼀种情况下getB⽅法是否可以正常返回结果
        assertEquals(0, ngn.getB());

        //指定1、2、3、4为第⼆种情况下的猜测数字
        Integer [] guesses1 = {4,3,2,1};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses1));

        //判断第⼆种情况下getB⽅法是否可以正常返回结果
        assertEquals(4, ngn.getB());

        //指定2,1,5,6为第三种情况下的猜测数字
        Integer [] guesses2 = {2,0,5,6};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses2));

        //判断第三种情况下getB⽅法是否可以正常返回结果
        assertEquals(1, ngn.getB());

        //指定2,1,5,6为第四种情况下的猜测数字
        Integer [] guesses3 = {2,1,5,6};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses3));

        //指定2,1,4,5为第四种情况下的猜测数字
        Integer [] guesses4 = {2,1,4,5};
        ngn.guesses = new ArrayList<Integer>(Arrays.asList(guesses4));

        //判断第三种情况下getB⽅法是否可以正常返回结果
        assertEquals(3, ngn.getB());
    }

}
